home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1998 June / SGI Freeware 1998 June.iso / dist / fw_UMINNgopher.idb / usr / freeware / src / gopher_1.12 / object / GDgopherdir.c.z / GDgopherdir.c
C/C++ Source or Header  |  1997-09-09  |  5KB  |  270 lines
  1. /********************************************************************
  2.  * $Author: drich $
  3.  * $Revision: 1.1 $
  4.  * $Date: 1995/10/03 04:09:42 $
  5.  * $Source: /proj/freeware1.0/gopher1.12/src/object/RCS/GDgopherdir.c,v $
  6.  * $Status: $
  7.  *
  8.  * Paul Lindner, University of Minnesota CIS.
  9.  *
  10.  * Copyright 1991, 1992 by the Regents of the University of Minnesota
  11.  * see the file "Copyright" in the distribution for conditions of use.
  12.  *********************************************************************
  13.  * MODULE: GDgopherdir.c
  14.  * Implement gopher directory routines
  15.  *********************************************************************
  16.  * Revision History:
  17.  * $Log: GDgopherdir.c,v $
  18.  * Revision 1.1  1995/10/03  04:09:42  drich
  19.  * gopher 1.2 check-in
  20.  *
  21.  * Revision 1.1  1992/12/10  23:27:52  lindner
  22.  * gopher 1.1 release
  23.  *
  24.  *
  25.  *********************************************************************/
  26.  
  27.  
  28. #include "GDgopherdir.h"
  29. #include "Malloc.h"
  30.  
  31.  
  32. #include <string.h>
  33. #include <stdio.h>
  34. extern int DEBUG;
  35.  
  36.  
  37. /***********************************************************************
  38. ** Stuff for GopherDirObjs
  39. **
  40. ***********************************************************************/
  41.  
  42.  
  43. GopherDirObj*
  44. GDnew(size)
  45.   int size;
  46. {
  47.      int i;
  48.      GopherDirObj *temp;
  49.      
  50.      temp = (GopherDirObj*) malloc(sizeof(GopherDirObj));
  51.  
  52.      temp->Gophers = DAnew(size, GSnew, GSinit, GSdestroy, GScpy);
  53.  
  54.      temp->Title = STRnew();
  55.      temp->currentitem = 1;
  56.  
  57.      GDinit(temp);
  58.      return(temp);
  59. }
  60.  
  61.  
  62. void
  63. GDdestroy(gd)
  64.   GopherDirObj *gd;
  65. {
  66.      int i;
  67.  
  68.      DAdestroy(gd->Gophers);
  69.      
  70.      STRdestroy(gd->Title);
  71.      free(gd);
  72. }
  73.  
  74.  
  75. void
  76. GDinit(gd)
  77.   GopherDirObj *gd;
  78. {
  79.      int i;
  80.  
  81.      DAinit(gd->Gophers);
  82.      STRinit(gd->Title);
  83. }
  84.  
  85.  
  86. extern int DEBUG;
  87.  
  88. /** This proc adds a GopherObj to a gopherdir. **/
  89. void
  90. GDaddGS(gd, gs)
  91.   GopherDirObj *gd;
  92.   GopherObj *gs;
  93. {
  94.     int top;
  95.  
  96.     DApush(gd->Gophers, gs);
  97. }
  98.  
  99.  
  100. /*
  101.  * Really weird!!!  We need this for qsort,  don't know why we can't use
  102.  * GScmp...
  103.  */
  104.  
  105. int
  106. GSqsortcmp(gs1, gs2)
  107.   GopherObj **gs1, **gs2;
  108. {
  109.      if (GSgetTitle(*gs1) == NULL)
  110.       return(1);
  111.      if (GSgetTitle(*gs2) == NULL)
  112.       return(-1);
  113.      
  114.      /** No numbering set on either entry, or both numbered
  115.          entries have the same number   **/
  116.  
  117.      if (GSgetNum(*gs1) == GSgetNum(*gs2))
  118.       return(strcmp(GSgetTitle(*gs1), GSgetTitle(*gs2)));
  119.  
  120.      /** first one numbered, second not **/
  121.      if (GSgetNum(*gs1) != -1 && GSgetNum(*gs2) == -1)
  122.       return(-1);
  123.  
  124.      /** second one numbered, first not **/
  125.      if (GSgetNum(*gs1) == -1 && GSgetNum(*gs2) != -1)
  126.       return(1);
  127.  
  128.      /** Both numbered, integer compare them **/
  129.  
  130.      return(GSgetNum(*gs1) - GSgetNum(*gs2));
  131. }
  132.  
  133. /*
  134.  * Sorts a gopher directory
  135.  */
  136.  
  137. void
  138. GDsort(gd)
  139.   GopherDirObj *gd;
  140. {
  141.  
  142.      DAsort(gd->Gophers, GSqsortcmp);
  143. }
  144.  
  145.  
  146. void
  147. GDtoNet(gd, sockfd)
  148.   GopherDirObj *gd;
  149.   int sockfd;
  150. {
  151.      int i;
  152.  
  153.      for (i=0; i< GDgetNumitems(gd); i++) {
  154.       GStoNet(GDgetEntry(gd, i), sockfd);
  155.      }      
  156.  
  157. }
  158.  
  159. void
  160. GDtoNetHTML(gd, sockfd)
  161.   GopherDirObj *gd;
  162.   int sockfd;
  163. {
  164.      int i;
  165.      
  166.      writestring(sockfd, "<MENU>\r\n");
  167.      
  168.      for (i=0; i< GDgetNumitems(gd); i++) {
  169.       writestring(sockfd, "<LI>");
  170.       GStoNetHTML(GDgetEntry(gd, i), sockfd);
  171.      }      
  172.      writestring(sockfd, "</MENU>");
  173. }
  174.  
  175.  
  176. /*
  177.  * Fill up a GopherDirObj with GopherObjs, given a gopher directory coming
  178.  * from sockfd.
  179.  *
  180.  * For each GopherObj retrieved, eachitem() is executed.
  181.  *
  182.  *  Returns 
  183.  
  184.  */
  185.  
  186. int
  187. GDfromNet(gd, sockfd, eachitem)
  188.   GopherDirObj *gd;
  189.   int sockfd;
  190.   int (*eachitem)();
  191. {
  192.      static GopherObj *TempGopher;
  193.      static char ZesTmp[1024];
  194.      int j, i;
  195.  
  196.      if (TempGopher == NULL)
  197.       TempGopher = GSnew();
  198.  
  199.      for (j=0; ; j++) {
  200.  
  201.       ZesTmp[0] = '\0';
  202.       
  203.       GSinit(TempGopher);
  204.       i = GSfromNet(TempGopher, sockfd);
  205.       
  206.       if (i==0) {
  207.            GDaddGS(gd, TempGopher);
  208.            if (eachitem != NULL) 
  209.             eachitem();
  210.       }
  211.  
  212.       else if (i==1)
  213.            return(j);
  214.  
  215.       /*** Unknown object type ***/
  216.       if (i== -2) {
  217.            j = j-1;
  218.            if (j<0) j=0;
  219.            readline(sockfd, ZesTmp, 1024); /** Get the rest of the line **/
  220.            ;
  221.       }
  222.       if (i==-1) {
  223.            j = j-1;
  224.            if (j<0) j=0;
  225.            readline(sockfd, ZesTmp, 1024); /** Get the rest of the line **/
  226.            return(j);
  227.       }
  228.      }
  229. } 
  230.  
  231.  
  232. /*
  233.  * Given an open file descriptor and an inited GopherDirobj,
  234.  *   read in gopher links, and add them to a gopherdir
  235.  */
  236.  
  237. void
  238. GDfromLink(gd, fd, host, port)
  239.   GopherDirObj *gd;
  240.   int          fd;
  241.   char         *host;
  242.   int          port;
  243. {
  244.      GopherObj *gs;
  245.  
  246.      gs = GSnew();
  247.  
  248.      while (GSfromLink(gs, fd, host, port) != -1) {
  249.       GDaddGS(gd, gs);
  250.       GSinit(gs);
  251.      }
  252.  
  253.      GSdestroy(gs);
  254. }
  255.  
  256.  
  257.  
  258. void
  259. GDtoLink(gd, fd)
  260.   GopherDirObj *gd;
  261.   int fd;
  262. {
  263.      int i;
  264.  
  265.      for (i=0; i< GDgetNumitems(gd); i++) {
  266.       GStoLink(GDgetEntry(gd, i), fd);
  267.      }      
  268.  
  269. }
  270.